// newapi/businessRoutes.js
const express = require('express');
const router = express.Router();
const Business = require('../../models/newmodels/businessSchema'); // 业务信息文档
const mongoose = require('mongoose');

// 创建一个新的业务记录
// router.post('/businesses', async (req, res) => {
//   try {
//     const business = new Business(req.body);
//     await business.save();
//     res.status(201).send({ code: '201', msg: '业务信息插入成功', data: business });
//   } catch (error) {
//     res.status(400).send({ code: '400', msg: '业务信息插入失败', data: error });
//   }
// });
// 

// -----------------依据用户ID和业务员ID实现创建接口

router.post('/businesses', async (req, res) => {
  console.log(req.body);

  try {
    const { machineId, userId } = req.body;

    if (!machineId || !userId) {
      return res.status(400).send({ code: '400', msg: 'machineId 和 userId 不能为空', data: null });
    }

    const business = new Business({
      machineId,
      userId,
      solutionInfo: "待补充方案信息"
    });

    await business.save();
    res.status(200).send({ code: '200', msg: '业务信息插入成功', data: business });
  } catch (error) {
    res.status(400).send({ code: '400', msg: '业务信息插入失败', data: error });
  }
});

// 获取所有业务记录
// router.get('/businessesFind', async (req, res) => { //依据业务的ID   实现查询所有的业务信息
//   console.log(req.body);

//   try {
//     const businesses = await Business.find().populate('machineId userId')//加上这个，会把对应的ID信息一起放回.populate('machineId userId')
//     // const businesses = await Business.find();
//     res.status(200).send({ code: '200', msg: '查询数据成功', data: businesses });
//   } catch (error) {
//     res.status(500).send({ code: '500', msg: '查询数据失败', data: error });
//   }
// });

router.get('/businessesFind', async (req, res) => {
  try {
    // 从查询参数中获取字段
    const { userId, status } = req.query;
    const query = {};
    console.log(req.query);


    // 构建查询条件
    if (userId) {
      //query.userId = mongoose.Types.ObjectId(userId); // 转换为 ObjectId
      query.userId = userId
    }
    if (status) {
      query.status = status;
    }

    console.log(query);

    // 执行查询（带关联数据）
    const businesses = await Business.find(query)
      .populate('machineId userId') // 关联机器和用户信息
      .lean(); // 转换为纯 JSON 对象

    res.status(200).send({
      code: '200',
      msg: '查询成功',
      data: businesses
    });

  } catch (error) {
    console.error('查询业务数据失败:', error);
    res.status(500).send({
      code: '500',
      msg: '查询数据失败',
      data: error.message // 返回具体错误信息
    });
  }
});

//依据传递的ID查询数据
// 根据业务ID查询业务详情
router.get('/businessesById', async (req, res) => {
  try {
    const { _id } = req.query;
    console.log(req.query);


    // 验证ID格式
    if (!mongoose.Types.ObjectId.isValid(_id)) {
      return res.status(400).send({
        code: '400',
        msg: '无效的业务ID格式',
        data: null
      });
    }

    // 查询数据库并关联用户/机器信息
    const business = await Business.findById(_id)
      .populate('machineId userId')
      .lean();

    if (!business) {
      return res.status(404).send({
        code: '404',
        msg: '未找到对应的业务记录',
        data: null
      });
    }

    res.status(200).send({
      code: '200',
      msg: '业务详情查询成功',
      data: business
    });

  } catch (error) {
    console.error('查询业务详情失败:', error);
    res.status(500).send({
      code: '500',
      msg: '业务详情查询失败',
      data: error.message
    });
  }
});

//
// 根据机器ID查询业务信息

router.get('/businessesByMachineId', async (req, res) => {
  try {
    const { machineId } = req.query;
    console.log('查询参数:', req.query);

    // 参数校验
    if (!machineId) {
      return res.status(400).json({
        code: '400',
        msg: 'machineId 不能为空',
        data: null
      });
    }

    // 验证 machineId 格式
    if (!mongoose.Types.ObjectId.isValid(machineId)) {
      return res.status(400).json({
        code: '400',
        msg: '无效的 machineId 格式',
        data: null
      });
    }

    // 构建查询条件
    const query = { machineId: new mongoose.Types.ObjectId(machineId) };

    // 执行查询（带关联数据）
    const businesses = await Business.findOne(query)
      .populate({
        path: 'machineId',
        // select: '_id machineName serialNumber' // 只返回需要的机器字段
      })
      .populate({
        path: 'userId',
        // select: '_id name email' // 只返回需要的用户字段
      })
      .select('-__v') // 排除版本字段
      .lean(); // 转换为纯 JSON 对象

    console.log(businesses);

    res.status(200).json({
      code: '200',
      msg: '查询成功',
      data: businesses
    });

  } catch (error) {
    console.error('查询业务数据失败:', error);
    res.status(500).json({
      code: '500',
      msg: '查询数据失败',
      data: error.message // 返回具体错误信息
    });
  }
});



// -----------------依据用户ID和业务员ID实现更新接口
// 更新业务记录（解决方案信息和收款状态）
// 更新业务记录（增强版）
router.put('/updateBusiness', async (req, res) => {
  try {
    const {
      _id,
      solutionInfo,
      isPaymentReceived,
      status  // 新增状态字段
    } = req.body;

    console.log(req.body);


    // 参数校验
    if (!_id) {
      return res.status(400).send({ code: '400', msg: '业务ID不能为空', data: null });
    }

    // 构建更新对象
    const updateFields = {
      updatedAt: Date.now()  // 自动更新修改时间
    };

    // 解决方案信息更新
    if (solutionInfo !== undefined) {
      updateFields.solutionInfo = solutionInfo;
    }

    // 收款状态更新
    if (isPaymentReceived !== undefined) {
      updateFields.isPaymentReceived = isPaymentReceived;
    }

    // 业务状态更新（带枚举校验）
    if (status) {
      if (!['待联系', '已处理', '滞留'].includes(status)) {
        return res.status(400).send({
          code: '400',
          msg: '无效的业务状态',
          data: null
        });
      }
      updateFields.status = status;
    }

    // 执行更新操作
    const updatedBusiness = await Business.findByIdAndUpdate(
      _id,
      updateFields,
      { new: true }
    ).populate('machineId userId');

    if (!updatedBusiness) {
      return res.status(404).send({
        code: '404',
        msg: '未找到对应业务记录',
        data: null
      });
    }

    res.status(200).send({
      code: 200,
      msg: '业务信息更新成功',
      data: updatedBusiness
    });

    console.log(updatedBusiness);

  } catch (error) {
    console.error('更新业务失败:', error);
    res.status(500).send({
      code: '500',
      msg: '业务信息更新失败',
      data: error.message
    });
  }
});

//传递业务id 修改业务单的状态
router.put('/updateBusinessStatus', async (req, res) => {
  try {
    const {
      _id,
      status  // 新增状态字段
    } = req.body;

    console.log(req.body);
    // 参数校验
    if (!_id) {
      return res.status(400).send({ code: '400', msg: '业务ID不能为空', data: null });
    }

    // 构建更新对象
    const updateFields = {
      updatedAt: Date.now()  // 自动更新修改时间
    };

    // 业务状态更新（带枚举校验）
    if (status) {
      if (!['待联系', '已处理', '滞留'].includes(status)) {
        return res.status(400).send({
          code: '400',
          msg: '无效的业务状态',
          data: null
        });
      }
      updateFields.status = status;
    }

    // 执行更新操作
    const updatedBusiness = await Business.findByIdAndUpdate(
      _id,
      updateFields,
      { new: true }
    ).populate('machineId userId');

    if (!updatedBusiness) {
      return res.status(404).send({
        code: '404',
        msg: '未找到对应业务记录',
        data: null
      });
    }

    res.status(200).send({
      code: 200,
      msg: '业务信息更新成功',
      data: updatedBusiness
    });

    console.log(updatedBusiness);

  } catch (error) {
    console.error('更新业务失败:', error);
    res.status(500).send({
      code: '500',
      msg: '业务信息更新失败',
      data: error.message
    });
  }

});


// 更新单个业务记录-------------更新模块










// // 删除单个业务记录
// router.delete('/businesses/:id', async (req, res) => {
//   try {
//     const business = await Business.findByIdAndDelete(req.params.id);
//     if (!business) {
//       return res.status(404).send({ code: '404', msg: '没有找到要删除的业务记录', data: null });
//     }
//     res.status(200).send({ code: '200', msg: '业务信息删除成功', data: business });
//   } catch (error) {
//     res.status(500).send({ code: '500', msg: '业务信息删除失败', data: error });
//   }
// });

module.exports = router;